#opcode systems

[opcodesystems]

Make music on vintage computer MIDI sequencers. Presented by Deep Signal Studios.

February 15th and 16th, Saturday & Sunday, 2025

Hotel Fera Event Center, Orange, Ca

https://www.vcfsocal.com/

[jellymeduza]

Hi Meduza, is it possible to make your flyable TS4 rocket charges money in SimPE? I’m thinking about increasing the prices of those aliens so that the trips have higher stakes. I would like to learn how to increase the logic points as well. Thanks for the great mods 🐸

Hi!

Sorry for replying so late. 😳

It is possible to make my rocket charge money for using it (currently using it is free), but it doesn't have anything to do with the price of the items a Sim may bring with them from their trip.

Making the rocket charge money

First, you need to edit [Text List] 0x0000012D in Text String (STR#) tab. Select any line on the list and click "Add". Change the new list to something like "I can't afford it!". Click "Commit File".

To make the usage of the rocket payable, you'd want to edit BHAV "Function - Ride - Start".

Click node 0x0. Using "Ins/false" button (it will appear after selecting "special buttons" checkbox) add node 0x1. Change node 0x1 to OpCode 0x0294 and node version to 0x00.

Click hammer and wrench icon and change the properties to something like mine:

"Amount" is the cost of the ride. Debit/Credit should be set to 0 and expense type to Const 0x013F:0x00 ("Misc Expense"). As Obj ID set My object ID.

Then using "Ins/false" button add node 0x2. Chnage the OpCode to 0x0002 [prim 0x0002] Expression. Using hammer and wrench set it to Stack Object ID 0x0000 := My 0x000B (object id). Set "False Target" to "Error".

Then click "Ins/true". Change thr OpCode of the new node 0x3 to 0x0024 and the "True Target" to "Return True". Click the hammer and wrench icon. Change the properties in the dialog box as follows:

Click node 0x1 Budget - Make Transaction once again. Change the "True Target" to node 0x0004.

Click "Commit File" and save.

2. Altering the price of items brought from a trip

I haven't done anything like that in any of my mod or object. However, my educated guess is that maybe altering BHAV "Interaction - Add something" could work. This is my suggestion, but I have no idea if it is going to work:

In BHAV "Interaction - Add something" select node 0x9 (Create New Object Instance) and select "Ins/True".

Select new node 0xA. Change the OpCode to [prim 0x0002] Expression. Click on the hammer and wrench icon and change the properties to "Stack Object's 0x0029 (current value) := Stack Object's definition 0x0012 (price)".

Then click "Ins/True" once more and select new node 0xB. Select the hammer and wrench icon and change the properties to "Stack Object's 0x0029 (current value) += Literal 0x0005". The "Literal" value in this case is how much you are going to increase object's price, so you can set it to whatever you like. Just remember that unless you tick the "decimal" box, the numbers are in hexadecimal system.

As I said, I don't know if it's going to work. Foremost, I don't know if changing the value in this manner is carried over if the object is added to Sim's inventory with the use of [global 0x044A] Inventory - Visible - Add Item.

It probably won't hurt to try it. 🤷‍♀️

[crow-musings]

I desprately need someone to talk to about this

I've been working on a system to allow a genetic algorithm to create DNA code which can create self-organising organisms. Someone I know has created a very effective genetic algorithm which blows NEAT out of the water in my opinion. So, this algorithm is very good at using food values to determine which organisms to breed, how to breed them, and the multitude of different biologically inspired mutation mechanisms which allow for things like meta genes and meta-meta genes, and a whole other slew of things. I am building a translation system, basically a compiler on top of it, and designing an instruction set and genetic repair mechanisms to allow it to convert ANY hexadecimal string into a valid, operable program. I'm doing this by having an organism with, so far, 5 planned chromosomes. The first and second chromosome are the INITIAL STATE of a neural network. The number and configuration of input nodes, the number and configuration of output nodes, whatever code it needs for a fitness function, and the configuration and weights of the layers. This neural network is not used at all in the fitness evaluation of the organism, but purely something the organism itself can manage, train, and utilize how it sees fit.

The third is the complete code of the program which runs the organism. Its basically a list of ASM opcodes and arguments written in hexadecimal. It is comprised of codons which represent the different hexadecimal characters, as well as a start and stop codon. This program will be compiled into executable machine code using LLVM IR and a custom instruction set I've designed for the organisms to give them a turing complete programming language and some helper functions to make certain processes simpler to evolve. This includes messages between the organisms, reproduction methods, and all the methods necessary for the organisms to develop sight, hearing, and recieve various other inputs, and also to output audio, video, and various outputs like mouse, keyboard, or a gamepad output. The fourth is a blank slate, which the organism can evolve whatever data it wants. The first half will be the complete contents of the organisms ROM after the important information, and the second half will be the initial state of the organisms memory. This will likely be stored as base 64 of its hash and unfolded into binary on compilation.

The 5th chromosome is one I just came up with and I am very excited about, it will be a translation dictionary. It will be 512 individual codons exactly, with each codon pair being mapped between 00 and FF hex. When evaulating the hex of the other chromosomes, this dictionary will be used to determine the equivalent instruction of any given hex pair. When evolving, each hex pair in the 5th organism will be guaranteed to be a valid opcode in the instruction set by using modulus to constrain each pair to the 55 instructions currently available. This will allow an organism to evolve its own instruction distribution, and try to prevent random instructions which might be harmful or inneficient from springing up as often, and instead more often select for efficient or safer instructions.

[piratesexmachine420]

Ehhh should I call an ambulance? You're writing assembly BY HAND?

Are you clinically insane or what?

Lol yeah x86 is an abomination -- we should've moved to ARM or PowerPC or something yesterday.

I just thought it'd be an instructive exercise to get down in the trenches for a sec -- I'm learning a lot about x64 opcodes, the System V ABI and all sorts of neat stuff. I'm hoping that in the next couple days I'll be able to write a little brainfuck compiler from scratch.

[michaelgogins]

Barry Vercoe (24 July 1937 – 16 June 2025)

I will not recapitulate what others have said in tribute to Barry Vercoe. You can read the Wikipedia article, or Richard Boulanger’s tribute (which is quoted in full here), or look at Barry’s old home page at the Massachusetts Institute of Technology, or read his New Zealand obituary.

Here I will offer my personal thanks to Barry for creating what, in my considered opinion, is one of the best musical instruments in history — Csound. I use it for almost all of my musical compositions.

There are now other systems, such as Max or Supercollider, that can do all, or almost all, of what Csound does. However, Csound came first, and is an ancestor of these systems. For at least some composers, such as myself, Csound is still easier to use, and perhaps more powerful. And just because it is older, Csound has the huge advantage of a very large base of running musical examples and pieces.

Here I will also offer my appreciation of Barry’s design choices and his implementation of Csound. My appreciation is based on my own experience, not only as an intensive user, but also as a sometime member of the Csound development team, when I contributed a number of features to Csound and came to understand Barry’s outstanding ability as a computer programmer.

There are some things I definitely do not like about the Csound code, mainly the cryptic names, and the use of preprocessor macros. Aside from that, here are a few of the good things in Barry’s code:

Of course the big home run was writing Csound in platform-neutral C, still the most performant programming language, and still available on more platforms than any other.

The extreme simplicity and efficiency of the inner loop for running Csound performances.

Invisible, automatic handling of multiple notes playing at the same time, for the same instrument.

The extremely flexible design for unit generators (opcodes), the building blocks of sound synthesis. Essentially, although written in C, Barry’s unit generators are classes -- data structures that derive from a virtual base class, and include methods for operating on their own data. The virtual base class idea makes it quite easy to extend Csound with new unit generators, and now even plugin unit generators.

The musical power and flexibility of Csound’s score language, which permits the user to define any set of fields for an event; and these fields are not limited to integer values, but are real numbers. Furthermore, based on his experience as a composer, Barry made sure his score language could handle tied notes, polyphony, changes of tempo, and so on. This is far more powerful than MIDI.

The policy of complete backwards compatibility. The very first examples and compositions still run on today's Csound!

Based on Barry's foundation, the current implementation of Csound (far more capable than the original) remains highly efficient, flexible, and easy to extend.

[mogwaipoet]

Live-coding a tracker in Commodore 64 BASIC

This design uses the BASIC prompt as an interface and the BASIC code listing as a save system. The bulk of the program is actually machine code -- DATA statements containing 6502 opcodes. This isn't too ridiculous, because the 6502 instruction set was designed to be hand-assembled. The ridiculous part is that Commodore 64 BASIC doesn't have hex literals, so the author must have memorized all the opcodes in decimal.

[flat-assembler]

A bit of actual Assembly knowledge for once. Let's cover some basic operations.

In C, to print something, you say:

printf("Hello, World!");

One argument. Very simple. Very understandable.

But it's not so easy in Assembly, is it?

Here's what the same looks like in Assembly, assuming you've properly declared a string called msg, and you're using Linux syntax (Assembly is formatted different between operating systems. I recommend Linux because it makes the most sense for developers).

mov rax, 1

mov rdi, 1

lea rsi, [msg]

mov rdx, 14

syscall

What's going on here?

Well, there are four parts to a simple print statement in Assembly. Each are put into place by registers in your CPU. rax, for example, is one of these registers.

We use mov to move values into the register. Notice that the syntax is: opcode destination, source

- rax holds the number for your function. In this case, 1 is used for print. (Full list of function numbers here)

- rdi holds the first argument in your function (arg0), which is 1 for standard output (stdout). For comparison, 0 is standard input (stdin)

- rsi (arg1) holds the actual text from the string. We use lea (load effective address) instead of mov, because if we used mov, we would get the memory address (location) of msg rather than the value of msg.

- rdx (arg2) holds the number of characters you want to print. There are 13 chars in our string msg: (Hello, World!). Thus, we allocate 14 characters, so we may also include a null character which says where to end the string.

- syscall basically just tells the computer to activate the function you have set up. Without it, you're just moving arbitrary values for no reason.

I know I know, it's a lot. But there is value in learning this language. Assembly runs way faster and uses much less space than higher level languages like C.

In my own experience, hello world code comes out to be about 15 kilobytes in C, but only about 200 bytes in Assembly. You read that right. Bytes. Without a kilo, mega or giga.

[willcodehtmlforfood]

"I designed my own 16-Bit Computer in Microsoft Excel without using Visual Basic scripts, plugins, or anything other than plain Excel. This system on a spreadsheet is based off of a custom Instruction Set Architecture that has a total of 23 instruction mnemonics and 26 opcodes.

The main design of the CPU is broken into a fetch unit, control unit, arithmetic logic unit, register file, PC unit, several multiplexers, a memory control unit, a 128KB RAM table, and a 128x128 16-color display."

@sztupy

[lazeecomet]

Thinking back on it, I did some really clever shit in my tenure as a field service engineer at the warehouse robotics company, that could have only worked because there were so many unsecured doors in the software

The V3s we had deployed when I first joined communicated with us over WiFi. We used Putty to remote in and run a long command to run the bootloader and start the main process

But you could also just run the main program without the long command. If you did that you could send opcodes to the motor controllers and get the wheels to turn or actuate functions. We were supposed to use this to run bench tests on test stands to ensure the robots were fit to put in production and home the motors

We did

But I also taught everyone how to send opcodes to manually drive the bots back to charging locations so we didnt have to push them. The only thing you had to be careful of was not putting a robot into production when it was running the program in the foreground as we called it. The long command to run in the background was needed as if you closed your putty window then the foreground program would stop

We did have someone crash a robot this way when they logged out while it was moving

But for being WiFi connected, this system was safer then you think as opcodes sent from a user could only be interpreted in foreground and system opcodes only received in background. Halting and restarting the program while the system was online would thow an error on the main command and control server that would put the robot out of service

Shit got wild when we upgraded to V4

Gone is the wifi in favor of 2.4 ghz radio. The robot also automatically runs the bootloader on power up. Foreground and background modes are a thing of the past. Now any commands sent on that radio channel, from the user or the command and control server, are accepted, no matter what

Granted, doing that while the system is on will desync the robot physically from what the system thinks is going on but it's smart enough to put the robot into ESTOP when the robot moves when it shouldn't

I however had different uses

There was several errors I encountered where I eventually diagnosed that the reason why a feature we had wasn't working was because the robot was given the opcode to move before it had been given the opcode to get ready to move

So the robot would try to move, fail to move, go Into ESTOP and then I'd step in. Id clear the estop on the robot locally with the estop clear opcode and send the opcode for getting ready to move. The robot, having gotten a command when it shouldn't, re-enters ESTOP and now everything is synced back up. I can now clear the estop normally and when the estop clears, the command server retries the last failed command. Now that the robot is ready to move, It drives away like nothing happened and operations resume

V5 shut down all my clever tricks. Maintenance mode is a physical switch that has to be pressed to do manually commands and pressing it power cycles the bot. Probably for the best tho

[hydralisk98]

Short sum for newbie system designer processor steps

Here are a few beginner projects for learning the ropes of customized computation architecture design:

Pana, a '4-4-4' instruction processor derived from Intersil 6100 & GaryExplains' but for 4-bit data. Uses the sixteen (16) RISC instructions shown by GaryExplains and only four (4) of its registers (ACC, PC, LN & MQ) as per of the Intersil 6100 specification. Doing as much work onto nibbles like an MVP Intel 4004 can, great as a BCD & Nibble data converter for later designs.

Tina, a barely expanded '4-4-8' processor derived from the "Pana" design, it uses more registers by adding twelve general-use registers (A-F, U-Z letters) and operate onto a single byte of data at a time. Great for two nibbles operations, byte-wise interoperability and 8-bit word compatibility with all sorts of modern processors from the seventies-onwards.

Milan, a '6-2-24' strong hybrid 8-bit / 12-bit processor derived from the "Tina" design, operating onto three bytes or two tribbles of data at once depending of use-case, while fitting in exactly 32-bit per instruction. Aimed at computing three 8-bit units, enabling 16-bit & 24-bit compatibility as well as up to two tribble operands. A great MVP implementation step towards my next own tribble computing architecture and a competitor to the Jack educational computer as shown in the NAND2Tetris courseware book.

When I am done with such, I will be onto three tribble-oriented architectures for lower-end, middle-end and upper-end "markets". Zara being lower-end (6-bit opcode, 6-bit register & 36-bit data = 48-bit instructions), Zorua being mid-end (8-bit opcode, 8-bit register and 48-bit data = 64-bit instructions) and Zoroark being upper-end (12-bit opcode, 36-bit register and 96/144-bit data (so either eight or twelve tribble operands worth of data) = 144/192-bit instructions, aiming to emulate close enough to an open-source IBM's PowerISA clone with VLIW & hot-swap computer architecture).

By the way, I haven't forgotten about the 16^12 Utalics game consoles and overall tech market overview + history specifications, nor have I forgotten about studying + importing + tinkering around things like Microdot & Gentoo & Tilck. I simply need to keep a reminder to myself for what to do first when I shall start with the computation engineering process. Hopefully that might be interesting for you to consider as well... Farewell!

EDIT #1

Tweaked and added some additional text & considering studying various aspects of Linux and overall copyleft / open source culture engineering scene, especially over Gentoo alternative kernels & hobby / homebrew standalone operating systems (GNU Hurd, OpenIndiana, Haiku... as well as niche ones like ZealOS, Parade, SerenityOS...) as to design a couple computation ecosystems (most derived from my constructed world which takes many hints from our real-life history) and choosing one among them to focus my implementation efforts onto as the "Nucleus" hybrid modular exo-kernel + my very own package modules collection. (Still aiming to be somewhat compatible with existing software following Unix philosophy principles too as to ease the developer learning cost in initial infrastructure compatibility & overall modularized complexity; Might also use some manifestation tips & games to enrich it with imports from said constructed world if possible)

[immediateedgebot25]

Immediate Edge Reviews - Is It Legit Or A Scam?

 Immediate Edge: We Should Build Them Ourselves

 Bitcoiners shouldn't sit around and wait for fiat banks and financial companies to offer services built on Bitcoin, we should do it ourselves.

Immediate Edge are going to happen.  We already have a few of them.  We’re going to have more of them.  Existing legacy banks are going to start offering services.  New banks are going to be founded around Bitcoin.  This is completely unavoidable at this point.  Bitcoin doesn’t scale.  Even absent that, people value other services that inherently require other parties.  Debt being the chief one.

This is an inescapable reality.

Even if we could snap our fingers and roll out every well specified opcode and covenant proposal at once, it would still take a lot of time to begin building out self-custodial layers that could compete with something like credit unions and banks offering bitcoin accounts at scale.  That is not a problem that can be trivially solved overnight.

So what can we do? 

We need to embrace a localist attitude around making interaction with your bitcoin easy.  This requires a two pronged approach, one involving technical development and the other involving, I hate to say it, lobbying.

There already exist pieces of software like LNDHub or LNBits that allow people to offer custodial accounts for Lightning.  We need a lot more software like this, and we need it to be miles better.  It needs to not involve tinkering around on the command line and hooking up independent software, or perusing Github to follow manual installation instructions, or fumbling around trying to fix dependencies mismatches.

 It needs to just work.

Click, sync to the network, done.  It needs to be something that power users who are still not very tech savvy can run safely, and not lose other people’s money.  It needs to support more than basic accounts for Lightning.  Ecash offers privacy, which would be something important when it comes to small groups of people who know each other. 

You don’t want your friend seeing what you spend your money on.  It needs to support things like Unchained or Nunchuck style on-chain self custody.  People aren’t going to want to hold all their friends and family’s life savings, but holding a recovery key to safeguard them from their own mistakes is another matter.

We need the software that will actually scale this type of user interaction beyond a bunch of activist nerds online.

We also need a regulatory carve out.  There needs to be a clear acknowledgement that running this type of software for friends and family with trivial amounts of money, say thousands of dollars, and without charging anything for it, is an unregulated activity. 

Helping friends and family interact with Bitcoin safely and easily, and for free, does not make you a bank.  The idea of a few thousand dollars needing to comply with the regulations banks managing billions of dollars do is frankly absurd.

This is the path forward given the current constraints of Bitcoin, and the reality of growing and accelerating adoption, that leads us away from a system that eventually becomes completely captured and neutered by legacy financial institutions.

We rely on each other to deal with Bitcoin's current scaling limitations rather than on them. This is a take article. The author is solely responsible for the content and does not necessarily represent BTC Inc.

https://www.immediateedgeapps.com/

[opcodesystems]

Come meet me and hang out at the Vintage Computer Fest in Orange, Ca this weekend, Feb 17th and 18th at booth E37. I’ll be showcasing some of our obsolete data storage drives, their media and audio media formats, how we transfer media to a modern platform for archival for clients, specializing in DAW and sequencer file conversion. I’ll have a PowerPC Mac running Vision, EZ Vision, Alchemy, Music Mouse with some synthesizer, sampler and drum machines. I’ll also have a demonstrations of sampler audio file transfer, Gotek floppy drive emulation, Greaseweasel, PiSCSI for Mac and samplers and our collection midi controlled vintage game console synthesizers: MidiNES, Midi Atari 2600 with Synthcart, SuperMidiPak and GenMDM.

[programmingandengineering]

CS342301 Operating System Pthreads Programming Assignment: Producer-Consumer Problem

Goal Understand how to work in the Linux environment. Understand how multi-thread programming can be done with the pthread library. Description The producer-consumer problem is a classic programming exercise in computer science. In this project, you will be given some Items, each Item contains an opcode, a key and a value. The producer and consumer are responsible to perform a transform…

[myprogrammingsolver]

CS342301 Operating System Pthreads Programming Assignment: Producer-Consumer Problem

Goal Understand how to work in the Linux environment. Understand how multi-thread programming can be done with the pthread library. Description The producer-consumer problem is a classic programming exercise in computer science. In this project, you will be given some Items, each Item contains an opcode, a key and a value. The producer and consumer are responsible to perform a transform…

[isabellaseraphinabloger]

Unveiling the Popularity of PHP in Web Development

In the realm of web development, PHP stands tall as one of the most prevalent and sought-after programming languages. PHP Is So Famous For Web Development that its presence permeates countless websites, from simple blogs to complex e-commerce platforms. But what exactly makes PHP so popular in this digital landscape?

Flexibility and Versatility: PHP's versatility is unmatched. Whether you're building a small personal website or a large-scale enterprise application, PHP provides the tools and features necessary to get the job done efficiently. Its flexibility allows developers to tailor solutions to meet specific needs, making it an ideal choice for a wide range of projects.

Open Source Nature: PHP's open-source nature has been a driving force behind its widespread adoption. As an open-source language, PHP is constantly evolving with contributions from a vast community of developers worldwide. This means frequent updates, bug fixes, and improvements, ensuring that PHP remains relevant and competitive in the ever-changing landscape of web development.

Ease of Learning and Deployment: One of the key reasons for PHP's popularity is its ease of learning. With a syntax that resembles natural language, beginners find it relatively easy to grasp the basics of PHP programming. Additionally, PHP integrates seamlessly with various web servers, making deployment a breeze. This accessibility lowers the entry barrier for aspiring developers, further fueling PHP's popularity.

Vast Ecosystem of Tools and Frameworks: PHP boasts a rich ecosystem of tools, frameworks, and libraries that expedite development processes. From popular frameworks like Laravel and Symfony to content management systems like WordPress and Drupal, developers have access to a plethora of resources that streamline development and enhance productivity.

Scalability and Performance: Despite its humble beginnings, PHP has evolved into a robust and scalable language capable of powering high-traffic websites and applications. With advancements in performance optimization techniques and the introduction of features like opcode caching, PHP can handle demanding workloads with ease, making it a reliable choice for projects of any scale.

In conclusion, the popularity of PHP in web development can be attributed to its flexibility, open-source nature, ease of learning, vast ecosystem, and scalability. As technology continues to evolve, PHP remains a cornerstone of the web development landscape, continuing to empower developers to create innovative and dynamic web experiences.

[michaelgogins]

More Notes on the Computer Music Playpen

I have finished maintenance on the VST3 plugin opcodes for Csound, Csound for Android, and some other things, and am re-focusing in composition.

One thing that happened as I was cleaning up the VST3 opcodes is that I discovered a very important thing. There are computer music programs that function as VST3 plugins and that significantly exceed the quality or power what Csound has so far done on it own, just for examples that I am using or plan to use:

The Valhalla reverbs by Sean Costello -- I think these actually derive from a reverb design that Sean did in the 1990s when he and I both were attending the Woof meetings at Columbia University. Sean's reverb design was ported first to Csound orchestra code, and then to C as a built-in opcode. It's the best and most widely used reverb in Csound, but it's not as good as the Valhalla reverbs, partly because the Valhalla reverbs can do a good job of preserving stereo.

Cardinal -- This is a fairly complete port of the VCV Rack "virtual Eurorack" patchable modular synthesiser not only to a VST3 plugin, but also to a WebAssembly module. This is exactly like sticking a very good Eurorack synthesizer right into Csound.

plugdata -- This is most of Pure Data, but with a slightly different and somewhat smoother user interface, as a VST3 plugin.

I also discovered that some popular digital audio workstations (DAWs), the workhorses of the popular music production industry, can embed algorithmic composition code written in a scripting language. For example, Reaper can host scripts written in Lua or Python, both of which are entirely capable of sophisticated algorithmic composition, and both of which have Csound APIs. And of course any of these DAWs can host Csound in the form of a Cabbage plugin.

All of this raises for me the question: What's the playpen? What's the most productive environment for me to compose in? Is it a DAW that now embeds my algorithms and my Csound instruments, or is it just code?

Right now the answer is not simply code, but specifically HTML5 code. And here is my experience and my reasons for not jumping to a DAW.

I don't want my pieces to break. I want my pieces to run in 20 years (assuming I am still around) just as they run today. Both HTML5 and Csound are "versionless" in the sense that they intend, and mostly succeed, in preserving complete backwards compatibility. There are Csound pieces from before 1990 that run just fine today -- that's over 33 years. But DAWs, so far, don't have such a good record in this department. I think many people find they have to keep porting older pieces to keep then running in newer software.

I'm always using a lot of resources, a lot of software, a lot of libraries. The HTML5 environment just makes this a great deal easier. Any piece of software that either is written in JavaScript or WebAssembly, or provides a JavaScript interface, can be used in a piece with a little but of JavaScript glue code. That includes Csound itself, my algorithmic composition software CsoundAC, the live coding system Strudel, and now Cardinal.

The Web browser itself contains a fantastic panoply of software, notably WebGL and WebAudio, so it's very easy to do visual music in the HTML5 environment.